/*
 * Copyright 2002-2007 the original author or authors.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
 */

package jacky.song.android.util.ref;

import jacky.song.android.util.Assert;
import jacky.song.android.util.closure.Composite;
import jacky.song.android.util.closure.Processor;

import java.lang.reflect.*;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;

/**
 * Simple utility class for working with the reflection API and handling reflection exceptions.
 * 
 * <p>
 * Only intended for internal use.
 * 
 * @author Juergen Hoeller
 * @author Rob Harrop
 * @author Rod Johnson
 * @author Costin Leau
 * @author Sam Brannen
 * @since 1.2.2
 */
public abstract class ReflectionUtils {
  
  /**
   * Attempt to find a {@link Field field} on the supplied {@link Class} with the supplied <code>name</code> and {@link Class type}. Searches all superclasses up to {@link Object}.
   * 
   * @param clazz
   *          the class to introspect
   * @param name
   *          the name of the field
   * @param type
   *          the type of the field
   * @return the corresponding Field object, or <code>null</code> if not found
   * @throws IllegalArgumentException
   *           if the class or field type is <code>null</code> or if the field name is <em>empty</em>
   */
  public static Field findField(final Class<?> clazz, final String name, final Class<?> type) {
    Assert.notNull(clazz, "The 'class to introspect' supplied to findField() can not be null.");
    Assert.hasText(name, "The field name supplied to findField() can not be empty.");
    Assert.notNull(type, "The field type supplied to findField() can not be null.");
    Class<?> searchType = clazz;
    while (!Object.class.equals(searchType) && searchType != null) {
      final Field[] fields = searchType.getDeclaredFields();
      for (int i = 0; i < fields.length; i++) {
        Field field = fields[i];
        if (name.equals(field.getName()) && type.equals(field.getType())) { return field; }
      }
      searchType = searchType.getSuperclass();
    }
    return null;
  }
  
  /**
   * Set the field represented by the supplied {@link Field field object} on the specified {@link Object target object} to the specified <code>value</code>. In accordance with {@link Field#set(Object, Object)} semantics, the new value is automatically unwrapped if the underlying field has a primitive type.
   * <p>
   * Thrown exceptions are handled via a call to {@link #handleReflectionException(Exception)}.
   * 
   * @param field
   *          the field to set
   * @param target
   *          the target object on which to set the field
   * @param value
   *          the value to set; may be <code>null</code>
   */
  public static void setField(Field field, Object target, Object value) {
    try {
      field.set(target, value);
    }
    catch (IllegalAccessException ex) {
      handleReflectionException(ex);
      throw new IllegalStateException("Unexpected reflection exception - " + ex.getClass().getName() + ": "
          + ex.getMessage());
    }
  }
  
  /**
   * Attempt to find a {@link Method} on the supplied class with the supplied name and no parameters. Searches all superclasses up to <code>Object</code>.
   * <p>
   * Returns <code>null</code> if no {@link Method} can be found.
   * 
   * @param clazz
   *          the class to introspect
   * @param name
   *          the name of the method
   * @return the Method object, or <code>null</code> if none found
   */
  public static Method findMethod(Class<?> clazz, String name) {
    return findMethod(clazz, name, new Class[0]);
  }
  
  /**
   * Attempt to find a {@link Method} on the supplied class with the supplied name and parameter types. Searches all superclasses up to <code>Object</code>.
   * <p>
   * Returns <code>null</code> if no {@link Method} can be found.
   * 
   * @param clazz
   *          the class to introspect
   * @param name
   *          the name of the method
   * @param paramTypes
   *          the parameter types of the method
   * @return the Method object, or <code>null</code> if none found
   */
  public static Method findMethod(Class<?> clazz, String name, Class<?>... paramTypes) {
    Assert.notNull(clazz, "Class must not be null");
    Assert.notNull(name, "Method name must not be null");
    Class<?> searchType = clazz;
    while (!Object.class.equals(searchType) && searchType != null) {
      Method[] methods = (searchType.isInterface() ? searchType.getMethods() : searchType.getDeclaredMethods());
      for (int i = 0; i < methods.length; i++) {
        Method method = methods[i];
        if (name.equals(method.getName()) && Arrays.equals(paramTypes, method.getParameterTypes())) { return method; }
      }
      searchType = searchType.getSuperclass();
    }
    return null;
  }
  
  /**
   * Invoke the specified {@link Method} against the supplied target object with no arguments. The target object can be <code>null</code> when invoking a static {@link Method}.
   * <p>
   * Thrown exceptions are handled via a call to {@link #handleReflectionException}.
   * 
   * @param method
   *          the method to invoke
   * @param target
   *          the target object to invoke the method on
   * @return the invocation result, if any
   * @see #invokeMethod(java.lang.reflect.Method, Object, Object[])
   */
  public static Object invokeMethod(Method method, Object target) {
    return invokeMethod(method, target, null);
  }
  
  /**
   * Invoke the specified {@link Method} against the supplied target object with the supplied arguments. The target object can be <code>null</code> when invoking a static {@link Method}.
   * <p>
   * Thrown exceptions are handled via a call to {@link #handleReflectionException}.
   * 
   * @param method
   *          the method to invoke
   * @param target
   *          the target object to invoke the method on
   * @param args
   *          the invocation arguments (may be <code>null</code>)
   * @return the invocation result, if any
   * @see #invokeMethod(java.lang.reflect.Method, Object, Object[])
   */
  public static Object invokeMethod(Method method, Object target, Object[] args) {
    try {
      return method.invoke(target, args);
    }
    catch (IllegalAccessException ex) {
      handleReflectionException(ex);
      throw new IllegalStateException("Unexpected reflection exception - " + ex.getClass().getName() + ": "
          + ex.getMessage());
    }
    catch (InvocationTargetException ex) {
      handleReflectionException(ex);
      throw new IllegalStateException("Unexpected reflection exception - " + ex.getClass().getName() + ": "
          + ex.getMessage());
    }
  }
  
  /**
   * Handle the given reflection exception. Should only be called if no checked exception is expected to be thrown by the target method.
   * <p>
   * Throws the underlying RuntimeException or Error in case of an InvocationTargetException with such a root cause. Throws an IllegalStateException with an appropriate message else.
   * 
   * @param ex
   *          the reflection exception to handle
   */
  public static void handleReflectionException(Exception ex) {
    if (ex instanceof NoSuchMethodException) { throw new IllegalStateException("Method not found: " + ex.getMessage()); }
    if (ex instanceof IllegalAccessException) { throw new IllegalStateException("Could not access method: "
        + ex.getMessage()); }
    if (ex instanceof InvocationTargetException) {
      handleInvocationTargetException((InvocationTargetException) ex);
    }
    throw new IllegalStateException("Unexpected reflection exception - " + ex.getClass().getName() + ": "
        + ex.getMessage());
  }
  
  /**
   * Handle the given invocation target exception. Should only be called if no checked exception is expected to be thrown by the target method.
   * <p>
   * Throws the underlying RuntimeException or Error in case of such a root cause. Throws an IllegalStateException else.
   * 
   * @param ex
   *          the invocation target exception to handle
   */
  public static void handleInvocationTargetException(InvocationTargetException ex) {
    if (ex.getTargetException() instanceof RuntimeException) { throw (RuntimeException) ex.getTargetException(); }
    if (ex.getTargetException() instanceof Error) { throw (Error) ex.getTargetException(); }
    throw new IllegalStateException("Unexpected exception thrown by method - "
        + ex.getTargetException().getClass().getName() + ": " + ex.getTargetException().getMessage());
  }
  
  /**
   * Rethrow the given {@link Throwable exception}, which is presumably the <em>target exception</em> of an {@link InvocationTargetException}. Should only be called if no checked exception is expected to be thrown by the target method.
   * <p>
   * Rethrows the underlying exception cast to an {@link Exception} or {@link Error} if appropriate; otherwise, throws an {@link IllegalStateException}.
   * 
   * @param ex
   *          the exception to rethrow
   * @throws Exception
   *           the rethrown exception (in case of a checked exception)
   */
  public static void rethrowException(Throwable ex) throws Exception {
    if (ex instanceof Exception) { throw (Exception) ex; }
    if (ex instanceof Error) { throw (Error) ex; }
    throw new IllegalStateException("Unexpected exception thrown by method - " + ex.getClass().getName() + ": "
        + ex.getMessage());
  }
  
  /**
   * Determine whether the given method explicitly declares the given exception or one of its superclasses, which means that an exception of that type can be propagated as-is within a reflective invocation.
   * 
   * @param method
   *          the declaring method
   * @param exceptionType
   *          the exception to throw
   * @return <code>true</code> if the exception can be thrown as-is; <code>false</code> if it needs to be wrapped
   */
  public static boolean declaresException(Method method, Class<?> exceptionType) {
    Assert.notNull(method, "Method must not be null");
    Class<?>[] declaredExceptions = method.getExceptionTypes();
    for (int i = 0; i < declaredExceptions.length; i++) {
      Class<?> declaredException = declaredExceptions[i];
      if (declaredException.isAssignableFrom(exceptionType)) { return true; }
    }
    return false;
  }
  
  /**
   * Determine whether the given field is a "public static final" constant.
   * 
   * @param field
   *          the field to check
   */
  public static boolean isPublicStaticFinal(Field field) {
    int modifiers = field.getModifiers();
    return (Modifier.isPublic(modifiers) && Modifier.isStatic(modifiers) && Modifier.isFinal(modifiers));
  }
  
  /**
   * Make the given field accessible, explicitly setting it accessible if necessary. The <code>setAccessible(true)</code> method is only called when actually necessary, to avoid unnecessary conflicts with a JVM SecurityManager (if active).
   * 
   * @param field
   *          the field to make accessible
   * @see java.lang.reflect.Field#setAccessible
   */
  public static void makeAccessible(Field field) {
    if (!Modifier.isPublic(field.getModifiers()) || !Modifier.isPublic(field.getDeclaringClass().getModifiers())) {
      field.setAccessible(true);
    }
  }
  
  /**
   * Make the given method accessible, explicitly setting it accessible if necessary. The <code>setAccessible(true)</code> method is only called when actually necessary, to avoid unnecessary conflicts with a JVM SecurityManager (if active).
   * 
   * @param method
   *          the method to make accessible
   * @see java.lang.reflect.Method#setAccessible
   */
  public static void makeAccessible(Method method) {
    if (!Modifier.isPublic(method.getModifiers()) || !Modifier.isPublic(method.getDeclaringClass().getModifiers())) {
      method.setAccessible(true);
    }
  }
  
  /**
   * Make the given constructor accessible, explicitly setting it accessible if necessary. The <code>setAccessible(true)</code> method is only called when actually necessary, to avoid unnecessary conflicts with a JVM SecurityManager (if active).
   * 
   * @param ctor
   *          the constructor to make accessible
   * @see java.lang.reflect.Constructor#setAccessible
   */
  public static void makeAccessible(Constructor<?> ctor) {
    if (!Modifier.isPublic(ctor.getModifiers()) || !Modifier.isPublic(ctor.getDeclaringClass().getModifiers())) {
      ctor.setAccessible(true);
    }
  }
  
  /**
   * Perform the given callback operation on all matching methods of the given class and superclasses.
   * <p>
   * The same named method occurring on subclass and superclass will appear twice, unless excluded by a {@link MethodFilter}.
   * 
   * @param targetClass
   *          class to start looking at
   * @param mc
   *          the callback to invoke for each method
   * @see #doWithMethods(Class, MethodCallback, MethodFilter)
   */
  public static void doWithMethods(Class<?> targetClass, MethodCallback mc) throws IllegalArgumentException {
    doWithMethods(targetClass, mc, null);
  }
  
  /**
   * Perform the given callback operation on all matching methods of the given class and superclasses.
   * <p>
   * The same named method occurring on subclass and superclass will appear twice, unless excluded by the specified {@link MethodFilter}.
   * 
   * @param targetClass
   *          class to start looking at
   * @param mc
   *          the callback to invoke for each method
   * @param mf
   *          the filter that determines the methods to apply the callback to
   */
  public static void doWithMethods(Class<?> targetClass, MethodCallback mc, MethodFilter mf)
      throws IllegalArgumentException {
    
    // Keep backing up the inheritance hierarchy.
    do {
      Method[] methods = targetClass.getDeclaredMethods();
      for (int i = 0; i < methods.length; i++) {
        if (mf != null && !mf.matches(methods[i])) {
          continue;
        }
        try {
          mc.doWith(methods[i]);
        }
        catch (IllegalAccessException ex) {
          throw new IllegalStateException("Shouldn't be illegal to access method '" + methods[i].getName() + "': " + ex);
        }
      }
      targetClass = targetClass.getSuperclass();
    } while (targetClass != null);
  }
  
  /**
   * Get all declared methods on the leaf class and all superclasses. Leaf class methods are included first.
   */
  public static Method[] getAllDeclaredMethods(Class<?> leafClass) throws IllegalArgumentException {
    final List<Method> list = new LinkedList<Method>();
    doWithMethods(leafClass, new MethodCallback() {
      
      @Override
      public void doWith(Method m) {
        list.add(m);
      }
    });
    return list.toArray(new Method[list.size()]);
  }
  
  /**
   * Invoke the given callback on all fields in the target class, going up the class hierarchy to get all declared fields.
   * 
   * @param targetClass
   *          the target class to analyze
   * @param fc
   *          the callback to invoke for each field
   */
  public static void doWithFields(Class<?> targetClass, FieldCallback fc) throws IllegalArgumentException {
    doWithFields(targetClass, fc, null);
  }
  
  /**
   * Invoke the given callback on all fields in the target class, going up the class hierarchy to get all declared fields.
   * 
   * @param targetClass
   *          the target class to analyze
   * @param fc
   *          the callback to invoke for each field
   * @param ff
   *          the filter that determines the fields to apply the callback to
   */
  public static void doWithFields(Class<?> targetClass, FieldCallback fc, FieldFilter ff)
      throws IllegalArgumentException {
    
    // Keep backing up the inheritance hierarchy.
    do {
      // Copy each field declared on this class unless it's static or file.
      Field[] fields = targetClass.getDeclaredFields();
      for (int i = 0; i < fields.length; i++) {
        // Skip static and final fields.
        if (ff != null && !ff.matches(fields[i])) {
          continue;
        }
        try {
          fc.doWith(fields[i]);
        }
        catch (IllegalAccessException ex) {
          throw new IllegalStateException("Shouldn't be illegal to access field '" + fields[i].getName() + "': " + ex);
        }
      }
      targetClass = targetClass.getSuperclass();
    } while (targetClass != null && targetClass != Object.class);
  }
  
  /**
   * Given the source object and the destination, which must be the same class or a subclass, copy all fields, including inherited fields. Designed to work on objects with public no-arg constructors.
   * 
   * @throws IllegalArgumentException
   *           if the arguments are incompatible
   */
  public static void shallowCopyFieldState(final Object src, final Object dest) throws IllegalArgumentException {
    if (src == null) { throw new IllegalArgumentException("Source for field copy cannot be null"); }
    if (dest == null) { throw new IllegalArgumentException("Destination for field copy cannot be null"); }
    if (!src.getClass().isAssignableFrom(dest.getClass())) { throw new IllegalArgumentException("Destination class ["
        + dest.getClass().getName() + "] must be same or subclass as source class [" + src.getClass().getName() + "]"); }
    doWithFields(src.getClass(), new ReflectionUtils.FieldCallback() {
      
      @Override
      public void doWith(Field field) throws IllegalArgumentException, IllegalAccessException {
        makeAccessible(field);
        Object srcValue = field.get(src);
        field.set(dest, srcValue);
      }
    }, ReflectionUtils.COPYABLE_FIELDS);
  }
  
  /**
   * Action to take on each method.
   */
  public static interface MethodCallback {
    
    /**
     * Perform an operation using the given method.
     * 
     * @param method
     *          the method to operate on
     */
    void doWith(Method method) throws IllegalArgumentException, IllegalAccessException;
  }
  
  /**
   * Callback optionally used to method fields to be operated on by a method callback.
   */
  public static interface MethodFilter {
    
    /**
     * JavaBean setter方法过滤器。
     */
    MethodFilter SETTER = new MethodFilter() {
      
      @Override
      public boolean matches(Method method) {
        return PUBLIC.matches(method) && VOID.matches(method) && !Modifier.isNative(method.getModifiers()) && // 非native
            
            method.getName().startsWith("set") //set开头
            && method.getParameterTypes().length == 1;//只有一个参数
      }
    };
    
    /**
     * JavaBean getter方法过滤器。
     */
    MethodFilter GETTER = new MethodFilter() {
      
      @Override
      public boolean matches(Method method) {
        return PUBLIC.matches(method) && NO_ARG.matches(method) && !Modifier.isNative(method.getModifiers()) && // 非native
            
            method.getName().startsWith("get") // get开头
            || method.getName().startsWith("is"); // 或者is开头(boolean型的isXXX，也是Getter)
      }
    };
    
    /**
     * <code>public</code> 方法过滤器。
     */
    MethodFilter PUBLIC = new MethodFilter() {
      
      @Override
      public boolean matches(Method method) {
        return Modifier.isPublic(method.getModifiers());
      }
    };
    
    /**
     * 无参数方法过滤器。
     */
    MethodFilter NO_ARG = new MethodFilter() {
      
      @Override
      public boolean matches(Method method) {
        return method.getParameterTypes().length == 0;
      }
    };
    
    /**
     * <code>void</code> 方法过滤器。
     */
    MethodFilter VOID = new MethodFilter() {
      
      @Override
      public boolean matches(Method method) {
        return method.getReturnType() == void.class;
      }
    };
    
    /**
     * “复合模式”实现的<code>MethodFilter</code> 的“与”操作， 包含过滤器指定的方法。
     */
    Composite<MethodFilter> INCLUDE = new Composite<MethodFilter>() {
      
      @Override
      public MethodFilter combine(final MethodFilter... parts) {
        return new MethodFilter() {
          
          @Override
          public boolean matches(Method method) {
            for (MethodFilter filter : parts) {
              if (!filter.matches(method)) { return false; }
            }
            return true;
          }
        };
      }
    };
    
    /**
     * “复合模式”实现的<code>MethodFilter</code> 的“非”操作， 排除过滤器指定的方法。
     */
    Composite<MethodFilter> EXCLUDE = new Composite<MethodFilter>() {
      
      @Override
      public MethodFilter combine(MethodFilter... parts) {
        return NOT.process(INCLUDE.combine(parts));//取反INCLUDE语意，即是EXCLUDE
      }
    };
    
    /**
     * “复合模式”实现的<code>MethodFilter</code> 的“或”操作。
     */
    Composite<MethodFilter> OR = new Composite<MethodFilter>() {
      
      @Override
      public MethodFilter combine(final MethodFilter... parts) {
        return new MethodFilter() {
          
          @Override
          public boolean matches(Method method) {
            for (MethodFilter filter : parts) {
              if (filter.matches(method)) { return true; }
            }
            return false;
          }
        };
      }
    };
    
    /**
     * <code>MethodFilter</code> 的“反转”操作， 把指定的 <code>MethodFilter</code> 语意取反。
     * <p>
     * 比如：<br/>
     * <code>NOT.doWith(VOID)</code> 会创建所有非void方法的 过滤器。
     */
    Processor<MethodFilter, MethodFilter> NOT = new Processor<MethodFilter, MethodFilter>() {
      
      @Override
      public MethodFilter process(final MethodFilter filter) {
        return new MethodFilter() {
          
          @Override
          public boolean matches(Method method) {
            return !filter.matches(method);
          }
        };
      }
    };
    
    /**
     * Determine whether the given method matches.
     * 
     * @param method
     *          the method to check
     */
    boolean matches(Method method);
  }
  
  /**
   * Callback interface invoked on each field in the hierarchy.
   */
  public static interface FieldCallback {
    
    /**
     * Perform an operation using the given field.
     * 
     * @param field
     *          the field to operate on
     */
    void doWith(Field field) throws IllegalArgumentException, IllegalAccessException;
  }
  
  /**
   * Callback optionally used to filter fields to be operated on by a field callback.
   */
  public static interface FieldFilter {
    
    /**
     * Determine whether the given field matches.
     * 
     * @param field
     *          the field to check
     */
    boolean matches(Field field);
  }
  
  /**
   * Pre-built FieldFilter that matches all non-static, non-final fields.
   */
  public static FieldFilter COPYABLE_FIELDS = new FieldFilter() {
    
    @Override
    public boolean matches(Field field) {
      return !(Modifier.isStatic(field.getModifiers()) || Modifier.isFinal(field.getModifiers()));
    }
  };

}
